import { defineStore } from 'pinia'
import type { UserInfo } from '../../../types/api'

// 用户状态接口
export interface UserState {
  // 用户信息
  userInfo: UserInfo | null
  userId: number
  
  // 会话相关
  sessionId: string
  
  // 认证相关
  token: string
  refreshToken: string
}

// 默认状态
const getDefaultState = (): UserState => ({
  userInfo: null,
  userId: 0,
  sessionId: '',
  token: '',
  refreshToken: ''
})

export const useUserStore = defineStore('user', {
  state: (): UserState => getDefaultState(),
  
  getters: {
    // 是否已登录
    isLoggedIn: (state) => !!state.userInfo,
    
    // 是否已认证 - 与isLoggedIn相同，但语义更明确
    isAuthenticated: (state) => !!state.userInfo,
    
    // 用户显示名称
    displayName: (state) => {
      if (state.userInfo) {
        return state.userInfo.nickname || state.userInfo.username || state.userInfo.id
      }
      return state.userId || '游客'
    },
    
    // 获取当前会话ID
    currentSessionId: (state) => state.sessionId,
    
    // 获取用户ID
    currentUserId: (state) => state.userId
  },
  
  actions: {
    // 初始化用户状态
    initUserState() {
      // 如果没有用户ID，生成一个游客ID
      if (!this.userId) {
        this.userId = Math.floor(100000 + Math.random() * 900000)
      }
      
      // 检查userId类型，如果是字符串则转换为数字
      if (typeof this.userId === 'string') {
        const parsedUserId = parseInt(this.userId, 10);
        if (!isNaN(parsedUserId)) {
          this.userId = parsedUserId;
          console.log('userStore.initUserState: 修复userId类型', typeof this.userId, this.userId);
        } else {
          console.error('userStore.initUserState: Failed to convert userId to number', this.userId);
          this.userId = Math.floor(100000 + Math.random() * 900000);
        }
      }
    },
    
    // 设置用户信息
    setUserInfo(userInfo: UserInfo | null) {
      this.userInfo = userInfo
      // 如果用户信息为空，也清除token
      if (!userInfo) {
        this.token = ''
        this.refreshToken = ''
      }
    },
    
    // 更新用户信息
    updateUserInfo(userInfo: Partial<UserInfo>) {
      if (this.userInfo) {
        this.userInfo = { ...this.userInfo, ...userInfo }
      }
    },
    
    // 设置用户ID
    setUserId(userId: number | string) {
      // 如果userId是字符串，尝试转换为数字
      if (typeof userId === 'string') {
        const parsedUserId = parseInt(userId, 10);
        if (!isNaN(parsedUserId)) {
          this.userId = parsedUserId;
          console.log('userStore.setUserId: 字符串转数字', userId, '=>', parsedUserId);
        } else {
          console.error('userStore.setUserId: 无法将字符串转换为数字', userId);
          this.userId = 0;
        }
      } else {
        this.userId = userId;
      }
    },
    
    // 设置token
    setToken(token: string) {
      console.log('userStore.setToken: 保存token', token ? '有效' : '无效或为空')
      this.token = token
      
      // 同时保存到localStorage，确保持久化
      if (token) {
        localStorage.setItem('auth_token', token)
      } else {
        localStorage.removeItem('auth_token')
      }
    },
    
    // 设置refresh token
    setRefreshToken(refreshToken: string) {
      this.refreshToken = refreshToken
      
      // 同时保存到localStorage，确保持久化
      if (refreshToken) {
        localStorage.setItem('refresh_token', refreshToken)
      } else {
        localStorage.removeItem('refresh_token')
      }
    },
    
    // 清除token
    clearToken() {
      this.token = ''
      this.refreshToken = ''
      
      // 同时清除localStorage
      localStorage.removeItem('auth_token')
      localStorage.removeItem('refresh_token')
    },
    
    // 获取token
    getToken(): string {
      // 如果store中有token，直接返回
      if (this.token) {
        console.log('userStore.getToken: 从store获取到token', '有效')
        return this.token
      }
      
      // 如果store中没有，尝试从localStorage获取
      const token = localStorage.getItem('auth_token')
      if (token) {
        // 同步到store
        this.token = token
        console.log('userStore.getToken: 从localStorage获取到token', '有效')
        return token
      }
      
      console.log('userStore.getToken: 未获取到token', '无效或为空')
      return ''
    },
    
    // 获取refresh token
    getRefreshToken(): string {
      // 如果store中有refreshToken，直接返回
      if (this.refreshToken) {
        return this.refreshToken
      }
      
      // 如果store中没有，尝试从localStorage获取
      const refreshToken = localStorage.getItem('refresh_token')
      if (refreshToken) {
        // 同步到store
        this.refreshToken = refreshToken
        return refreshToken
      }
      
      return ''
    },
    
    // 会话相关方法
    // 设置会话ID
    setSessionId(sessionId: string) {
      this.sessionId = sessionId
    },
    
    // 设置当前会话ID
    setCurrentSessionId(sessionId: string) {
      this.sessionId = sessionId
    },
    
    // 清除会话ID
    clearSessionId() {
      this.sessionId = ''
    },
    
    // 初始化会话状态
    async initialize() {
      try {
        // 从chat store中获取当前会话ID
        const { useChatStore } = await import('../../chat/stores/chat')
        const chatStore = useChatStore()
        
        if (!this.sessionId && chatStore.currentSessionId) {
          this.sessionId = chatStore.currentSessionId
        }
        
        // 如果没有会话ID，创建一个新会话
        if (!this.sessionId) {
          this.sessionId = await this.createNewSession()
        }
      } catch (err: any) {
        console.error('userStore.initialize: 初始化会话状态失败', err instanceof Error ? err.message : String(err));
      }
    },
    
    // 创建新会话
    async createNewSession(): Promise<string> {
      // 生成新的会话ID
      const sessionId = `${this.userId}_${Math.floor(Math.random() * 1000000).toString().padStart(6, '0')}`
      this.setSessionId(sessionId)
      return sessionId
    },
    
    // 重置用户状态
    resetUserState() {
      // 重置为默认状态
      Object.assign(this, getDefaultState())
    },
    
    // 登出方法
    logout() {
      // 清除用户信息
      this.setUserInfo(null)
      // 清除token
      this.clearToken()
      // 重置用户状态
      this.resetUserState()
    }
  },
  
  // 配置持久化
  persist: {
    key: 'user-store',
    storage: localStorage,
    // 指定需要持久化的字段
    pick: [
      'userInfo',
      'userId',
      'sessionId',
      'token',
      'refreshToken'
    ]
  }
})

// 导出用户存储类型
export type UserStore = ReturnType<typeof useUserStore>